home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / X11R4 / cmds / X / dix / swapreq.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-06  |  25.2 KB  |  1,123 lines
  1. /************************************************************
  2. Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
  3. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Digital or MIT not be
  12. used in advertising or publicity pertaining to distribution of the
  13. software without specific, written prior permission.  
  14.  
  15. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  16. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  17. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  18. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  19. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  20. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  21. SOFTWARE.
  22.  
  23. ********************************************************/
  24.  
  25. /* $XConsortium: swapreq.c,v 1.29 89/07/03 19:50:28 rws Exp $ */
  26. /* $Header: /X11/R4/src/cmds/X/dix/RCS/swapreq.c,v 1.2 91/02/05 17:32:05 kupfer Exp $ */
  27.  
  28. #include "X.h"
  29. #define NEED_EVENTS
  30. #include "Xproto.h"
  31. #include "Xprotostr.h"
  32. #include "misc.h"
  33. #include "dixstruct.h"
  34.  
  35. extern int (* ProcVector[256]) ();
  36. extern void (* EventSwapVector[128]) ();  /* for SendEvent */
  37.  
  38. /* Thanks to Jack Palevich for testing and subsequently rewriting all this */
  39.  
  40. /* Byte swap a list of longs */
  41.  
  42. void
  43. SwapLongs (list, count)
  44.     register long *list;
  45.     register unsigned long count;
  46. {
  47.     register int n;
  48.  
  49.     while (count >= 8) {
  50.         swapl(list+0, n);
  51.         swapl(list+1, n);
  52.         swapl(list+2, n);
  53.         swapl(list+3, n);
  54.         swapl(list+4, n);
  55.         swapl(list+5, n);
  56.         swapl(list+6, n);
  57.         swapl(list+7, n);
  58.         list += 8;
  59.         count -= 8;
  60.     }
  61.     if (count != 0) {
  62.         do {
  63.         swapl(list, n);
  64.         list++;
  65.         } while (--count != 0);
  66.     }
  67. }
  68.  
  69. /* Byte swap a list of shorts */
  70.  
  71. void
  72. SwapShorts (list, count)
  73.     register short *list;
  74.     register unsigned long count;
  75. {
  76.     register int n;
  77.  
  78.     while (count >= 16) {
  79.         swaps(list+0, n);
  80.         swaps(list+1, n);
  81.         swaps(list+2, n);
  82.         swaps(list+3, n);
  83.         swaps(list+4, n);
  84.         swaps(list+5, n);
  85.         swaps(list+6, n);
  86.         swaps(list+7, n);
  87.         swaps(list+8, n);
  88.         swaps(list+9, n);
  89.         swaps(list+10, n);
  90.         swaps(list+11, n);
  91.         swaps(list+12, n);
  92.         swaps(list+13, n);
  93.         swaps(list+14, n);
  94.         swaps(list+15, n);
  95.         list += 16;
  96.         count -= 16;
  97.     }
  98.     if (count != 0) {
  99.         do {
  100.         swaps(list, n);
  101.         list++;
  102.         } while (--count != 0);
  103.     }
  104. }
  105.  
  106. /* The following is used for all requests that have
  107.    no fields to be swapped (except "length") */
  108. int
  109. SProcSimpleReq(client)
  110.     register ClientPtr client;
  111. {
  112.     register char n;
  113.  
  114.     REQUEST(xReq);
  115.     swaps(&stuff->length, n);
  116.     return(*ProcVector[stuff->reqType])(client);
  117. }
  118.  
  119. /* The following is used for all requests that have
  120.    only a single 32-bit field to be swapped, coming
  121.    right after the "length" field */
  122. int
  123. SProcResourceReq(client)
  124.     register ClientPtr client;
  125. {
  126.     register char n;
  127.  
  128.     REQUEST(xResourceReq);
  129.     swaps(&stuff->length, n);
  130.     swapl(&stuff->id, n);
  131.     return(*ProcVector[stuff->reqType])(client);
  132. }
  133.  
  134. int
  135. SProcCreateWindow(client)
  136.     register ClientPtr client;
  137. {
  138.     register char n;
  139.  
  140.     REQUEST(xCreateWindowReq);
  141.     swaps(&stuff->length, n);
  142.     REQUEST_AT_LEAST_SIZE(xCreateWindowReq);
  143.     swapl(&stuff->wid, n);
  144.     swapl(&stuff->parent, n);
  145.     swaps(&stuff->x, n);
  146.     swaps(&stuff->y, n);
  147.     swaps(&stuff->width, n);
  148.     swaps(&stuff->height, n);
  149.     swaps(&stuff->borderWidth, n);
  150.     swaps(&stuff->class, n);
  151.     swapl(&stuff->visual, n);
  152.     swapl(&stuff->mask, n);
  153.     SwapRestL(stuff);
  154.     return((* ProcVector[X_CreateWindow])(client));
  155. }
  156.  
  157. int
  158. SProcChangeWindowAttributes(client)
  159.     register ClientPtr client;
  160. {
  161.     register char n;
  162.  
  163.     REQUEST(xChangeWindowAttributesReq);
  164.     swaps(&stuff->length, n);
  165.     REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq);
  166.     swapl(&stuff->window, n);
  167.     swapl(&stuff->valueMask, n);
  168.     SwapRestL(stuff);
  169.     return((* ProcVector[X_ChangeWindowAttributes])(client));
  170. }
  171.  
  172. int
  173. SProcReparentWindow(client)
  174.     register ClientPtr client;
  175. {
  176.     register char n;
  177.     REQUEST(xReparentWindowReq);
  178.     swaps(&stuff->length, n);
  179.     swapl(&stuff->window, n);
  180.     swapl(&stuff->parent, n);
  181.     swaps(&stuff->x, n);
  182.     swaps(&stuff->y, n);
  183.     return((* ProcVector[X_ReparentWindow])(client));
  184. }
  185.  
  186. int
  187. SProcConfigureWindow(client)
  188.     register ClientPtr client;
  189. {
  190.     register char n;
  191.     REQUEST(xConfigureWindowReq);
  192.     swaps(&stuff->length, n);
  193.     REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);
  194.     swapl(&stuff->window, n);
  195.     swaps(&stuff->mask, n);
  196.     SwapRestL(stuff);
  197.     return((* ProcVector[X_ConfigureWindow])(client));
  198.  
  199. }
  200.  
  201.  
  202. int
  203. SProcInternAtom(client)
  204.     register ClientPtr client;
  205. {
  206.     register char n;
  207.     REQUEST(xInternAtomReq);
  208.     swaps(&stuff->length, n);
  209.     swaps(&stuff->nbytes, n);
  210.     return((* ProcVector[X_InternAtom])(client));
  211. }
  212.  
  213. int
  214. SProcChangeProperty(client)
  215.     register ClientPtr client;
  216. {
  217.     register char n;
  218.     REQUEST(xChangePropertyReq);
  219.     swaps(&stuff->length, n);
  220.     swapl(&stuff->window, n);
  221.     swapl(&stuff->property, n);
  222.     swapl(&stuff->type, n);
  223.     swapl(&stuff->nUnits, n);
  224.     switch ( stuff->format ) {
  225.         case 8 : break;
  226.         case 16:
  227.             SwapShorts((short *)(stuff + 1), stuff->nUnits);
  228.         break;
  229.     case 32:
  230.         SwapLongs((long *)(stuff + 1), stuff->nUnits);
  231.         break;
  232.     }
  233.     return((* ProcVector[X_ChangeProperty])(client));
  234. }
  235.  
  236. int 
  237. SProcDeleteProperty(client)
  238.     register ClientPtr client;
  239. {
  240.     register char n;
  241.     REQUEST(xDeletePropertyReq);
  242.     swaps(&stuff->length, n);
  243.     swapl(&stuff->window, n);
  244.     swapl(&stuff->property, n);
  245.     return((* ProcVector[X_DeleteProperty])(client));
  246.               
  247. }
  248.  
  249. int 
  250. SProcGetProperty(client)
  251.     register ClientPtr client;
  252. {
  253.     register char n;
  254.     REQUEST(xGetPropertyReq);
  255.     swaps(&stuff->length, n);
  256.     swapl(&stuff->window, n);
  257.     swapl(&stuff->property, n);
  258.     swapl(&stuff->type, n);
  259.     swapl(&stuff->longOffset, n);
  260.     swapl(&stuff->longLength, n);
  261.     return((* ProcVector[X_GetProperty])(client));
  262. }
  263.  
  264. int
  265. SProcSetSelectionOwner(client)
  266.     register ClientPtr client;
  267. {
  268.     register char n;
  269.     REQUEST(xSetSelectionOwnerReq);
  270.     swaps(&stuff->length, n);
  271.     swapl(&stuff->window, n);
  272.     swapl(&stuff->selection, n);
  273.     swapl(&stuff->time, n);
  274.     return((* ProcVector[X_SetSelectionOwner])(client));
  275. }
  276.  
  277. int
  278. SProcConvertSelection(client)
  279.     register ClientPtr client;
  280. {
  281.     register char n;
  282.     REQUEST(xConvertSelectionReq);
  283.     swaps(&stuff->length, n);
  284.     swapl(&stuff->requestor, n);
  285.     swapl(&stuff->selection, n);
  286.     swapl(&stuff->target, n);
  287.     swapl(&stuff->property, n);
  288.     swapl(&stuff->time, n);
  289.     return((* ProcVector[X_ConvertSelection])(client));
  290. }
  291.  
  292. int
  293. SProcSendEvent(client)
  294.     register ClientPtr client;
  295. {
  296.     register char n;
  297.     xEvent eventT;
  298.     void (*proc)();
  299.     REQUEST(xSendEventReq);
  300.     swaps(&stuff->length, n);
  301.     swapl(&stuff->destination, n);
  302.     swapl(&stuff->eventMask, n);
  303.  
  304.     /* Swap event */
  305.     proc = EventSwapVector[stuff->event.u.u.type & 0177];
  306.     if (!proc)   /* no swapping proc; invalid event type? */
  307.        return (BadValue);
  308.     (*proc)(&stuff->event, &eventT);
  309.     stuff->event = eventT;
  310.  
  311.     return((* ProcVector[X_SendEvent])(client));
  312. }
  313.  
  314. int
  315. SProcGrabPointer(client)
  316.     register ClientPtr client;
  317. {
  318.     register char n;
  319.     REQUEST(xGrabPointerReq);
  320.     swaps(&stuff->length, n);
  321.     swapl(&stuff->grabWindow, n);
  322.     swaps(&stuff->eventMask, n);
  323.     swapl(&stuff->confineTo, n);
  324.     swapl(&stuff->cursor, n);
  325.     swapl(&stuff->time, n);
  326.     return((* ProcVector[X_GrabPointer])(client));
  327. }
  328.  
  329. int
  330. SProcGrabButton(client)
  331.     register ClientPtr client;
  332. {
  333.     register char n;
  334.     REQUEST(xGrabButtonReq);
  335.     swaps(&stuff->length, n);
  336.     swapl(&stuff->grabWindow, n);
  337.     swaps(&stuff->eventMask, n);
  338.     swapl(&stuff->confineTo, n);
  339.     swapl(&stuff->cursor, n);
  340.     swaps(&stuff->modifiers, n);
  341.     return((* ProcVector[X_GrabButton])(client));
  342. }
  343.  
  344. int
  345. SProcUngrabButton(client)
  346.     register ClientPtr client;
  347. {
  348.     register char n;
  349.     REQUEST(xUngrabButtonReq);
  350.     swaps(&stuff->length, n);
  351.     swapl(&stuff->grabWindow, n);
  352.     swaps(&stuff->modifiers, n);
  353.     return((* ProcVector[X_UngrabButton])(client));
  354. }
  355.  
  356. int
  357. SProcChangeActivePointerGrab(client)
  358.     register ClientPtr client;
  359. {
  360.     register char n;
  361.     REQUEST(xChangeActivePointerGrabReq);
  362.     swaps(&stuff->length, n);
  363.     swapl(&stuff->cursor, n);
  364.     swapl(&stuff->time, n);
  365.     swaps(&stuff->eventMask, n);
  366.     return((* ProcVector[X_ChangeActivePointerGrab])(client));
  367. }
  368.  
  369. int
  370. SProcGrabKeyboard(client)
  371.     register ClientPtr client;
  372. {
  373.     register char n;
  374.     REQUEST(xGrabKeyboardReq);
  375.     swaps(&stuff->length, n);
  376.     swapl(&stuff->grabWindow, n);
  377.     swapl(&stuff->time, n);
  378.     return((* ProcVector[X_GrabKeyboard])(client));
  379. }
  380.  
  381. int
  382. SProcGrabKey(client)
  383.     register ClientPtr client;
  384. {
  385.     register char n;
  386.     REQUEST(xGrabKeyReq);
  387.     swaps(&stuff->length, n);
  388.     swapl(&stuff->grabWindow, n);
  389.     swaps(&stuff->modifiers, n);
  390.     return((* ProcVector[X_GrabKey])(client));
  391. }
  392.  
  393. int
  394. SProcUngrabKey(client)
  395.     register ClientPtr client;
  396. {
  397.     register char n;
  398.     REQUEST(xUngrabKeyReq);
  399.     swaps(&stuff->length, n);
  400.     swapl(&stuff->grabWindow, n);
  401.     swaps(&stuff->modifiers, n);
  402.     return((* ProcVector[X_UngrabKey])(client));
  403. }
  404.  
  405. int
  406. SProcGetMotionEvents(client)
  407.     register ClientPtr client;
  408. {
  409.     register char n;
  410.     REQUEST(xGetMotionEventsReq);
  411.     swaps(&stuff->length, n);
  412.     swapl(&stuff->window, n);
  413.     swapl(&stuff->start, n);
  414.     swapl(&stuff->stop, n);
  415.     return((* ProcVector[X_GetMotionEvents])(client));
  416. }
  417.  
  418. int
  419. SProcTranslateCoords(client)
  420.     register ClientPtr client;
  421. {
  422.     register char n;
  423.     REQUEST(xTranslateCoordsReq);
  424.     swaps(&stuff->length, n);
  425.     swapl(&stuff->srcWid, n);
  426.     swapl(&stuff->dstWid, n);
  427.     swaps(&stuff->srcX, n);
  428.     swaps(&stuff->srcY, n);
  429.     return((* ProcVector[X_TranslateCoords])(client));
  430. }
  431.  
  432. int
  433. SProcWarpPointer(client)
  434.     register ClientPtr client;
  435. {
  436.     register char n;
  437.     REQUEST(xWarpPointerReq);
  438.     swaps(&stuff->length, n);
  439.     swapl(&stuff->srcWid, n);
  440.     swapl(&stuff->dstWid, n);
  441.     swaps(&stuff->srcX, n);
  442.     swaps(&stuff->srcY, n);
  443.     swaps(&stuff->srcWidth, n);
  444.     swaps(&stuff->srcHeight, n);
  445.     swaps(&stuff->dstX, n);
  446.     swaps(&stuff->dstY, n);
  447.     return((* ProcVector[X_WarpPointer])(client));
  448. }
  449.  
  450. int
  451. SProcSetInputFocus(client)
  452.     register ClientPtr client;
  453. {
  454.     register char n;
  455.     REQUEST(xSetInputFocusReq);
  456.     swaps(&stuff->length, n);
  457.     swapl(&stuff->focus, n);
  458.     swapl(&stuff->time, n);
  459.     return((* ProcVector[X_SetInputFocus])(client));
  460. }
  461.  
  462.  
  463. SProcOpenFont(client)
  464.     register ClientPtr client;
  465. {
  466.     register char n;
  467.     REQUEST(xOpenFontReq);
  468.     swaps(&stuff->length, n);
  469.     swapl(&stuff->fid, n);
  470.     swaps(&stuff->nbytes, n);
  471.     return((* ProcVector[X_OpenFont])(client));
  472. }
  473.  
  474. int
  475. SProcListFonts(client)
  476.     register ClientPtr client;
  477. {
  478.     register char n;
  479.     REQUEST(xListFontsReq);
  480.     swaps(&stuff->length, n);
  481.     swaps(&stuff->maxNames, n);
  482.     swaps(&stuff->nbytes, n);
  483.     return((* ProcVector[X_ListFonts])(client));
  484. }
  485.  
  486. int
  487. SProcListFontsWithInfo(client)
  488.     register ClientPtr client;
  489. {
  490.     register char n;
  491.     REQUEST(xListFontsWithInfoReq);
  492.     swaps(&stuff->length, n);
  493.     swaps(&stuff->maxNames, n);
  494.     swaps(&stuff->nbytes, n);
  495.     return((* ProcVector[X_ListFontsWithInfo])(client));
  496. }
  497.  
  498. int
  499. SProcSetFontPath(client)
  500.     register ClientPtr client;
  501. {
  502.     register char n;
  503.     REQUEST(xSetFontPathReq);
  504.     swaps(&stuff->length, n);
  505.     swaps(&stuff->nFonts, n);
  506.     return((* ProcVector[X_SetFontPath])(client));
  507. }
  508.  
  509. int
  510. SProcCreatePixmap(client)
  511.     register ClientPtr client;
  512. {
  513.     register char n;
  514.     REQUEST(xCreatePixmapReq);
  515.  
  516.     swaps(&stuff->length, n);
  517.     swapl(&stuff->pid, n);
  518.     swapl(&stuff->drawable, n);
  519.     swaps(&stuff->width, n);
  520.     swaps(&stuff->height, n);
  521.     return((* ProcVector[X_CreatePixmap])(client));
  522. }
  523.  
  524. int
  525. SProcCreateGC(client)
  526.     register ClientPtr client;
  527. {
  528.     register char n;
  529.     REQUEST(xCreateGCReq);
  530.     swaps(&stuff->length, n);
  531.     REQUEST_AT_LEAST_SIZE(xCreateGCReq);
  532.     swapl(&stuff->gc, n);
  533.     swapl(&stuff->drawable, n);
  534.     swapl(&stuff->mask, n);
  535.     SwapRestL(stuff);
  536.     return((* ProcVector[X_CreateGC])(client));
  537. }
  538.  
  539. int
  540. SProcChangeGC(client)
  541.     register ClientPtr client;
  542. {
  543.     register char n;
  544.     REQUEST(xChangeGCReq);
  545.     swaps(&stuff->length, n);
  546.     REQUEST_AT_LEAST_SIZE(xChangeGCReq);
  547.     swapl(&stuff->gc, n);
  548.     swapl(&stuff->mask, n);
  549.     SwapRestL(stuff);
  550.     return((* ProcVector[X_ChangeGC])(client));
  551. }
  552.  
  553. int
  554. SProcCopyGC(client)
  555.     register ClientPtr client;
  556. {
  557.     register char n;
  558.     REQUEST(xCopyGCReq);
  559.     swaps(&stuff->length, n);
  560.     swapl(&stuff->srcGC, n);
  561.     swapl(&stuff->dstGC, n);
  562.     swapl(&stuff->mask, n);
  563.     return((* ProcVector[X_CopyGC])(client));
  564. }
  565.  
  566. int
  567. SProcSetDashes(client)
  568.     register ClientPtr client;
  569. {
  570.     register char n;
  571.     REQUEST(xSetDashesReq);
  572.     swaps(&stuff->length, n);
  573.     swapl(&stuff->gc, n);
  574.     swaps(&stuff->dashOffset, n);
  575.     swaps(&stuff->nDashes, n);
  576.     return((* ProcVector[X_SetDashes])(client));
  577.  
  578. }
  579.  
  580. int
  581. SProcSetClipRectangles(client)
  582.     register ClientPtr client;
  583. {
  584.     register char n;
  585.     REQUEST(xSetClipRectanglesReq);
  586.     swaps(&stuff->length, n);
  587.     swapl(&stuff->gc, n);
  588.     swaps(&stuff->xOrigin, n);
  589.     swaps(&stuff->yOrigin, n);
  590.     SwapRestS(stuff);
  591.     return((* ProcVector[X_SetClipRectangles])(client));
  592. }
  593.  
  594. int
  595. SProcClearToBackground(client)
  596.     register ClientPtr client;
  597. {
  598.     register char n;
  599.     REQUEST(xClearAreaReq);
  600.     swaps(&stuff->length, n);
  601.     swapl(&stuff->window, n);
  602.     swaps(&stuff->x, n);
  603.     swaps(&stuff->y, n);
  604.     swaps(&stuff->width, n);
  605.     swaps(&stuff->height, n);
  606.     return((* ProcVector[X_ClearArea])(client));
  607. }
  608.  
  609. int
  610. SProcCopyArea(client)
  611.     register ClientPtr client;
  612. {
  613.     register char n;
  614.     REQUEST(xCopyAreaReq);
  615.     swaps(&stuff->length, n);
  616.     swapl(&stuff->srcDrawable, n);
  617.     swapl(&stuff->dstDrawable, n);
  618.     swapl(&stuff->gc, n);
  619.     swaps(&stuff->srcX, n);
  620.     swaps(&stuff->srcY, n);
  621.     swaps(&stuff->dstX, n);
  622.     swaps(&stuff->dstY, n);
  623.     swaps(&stuff->width, n);
  624.     swaps(&stuff->height, n);
  625.     return((* ProcVector[X_CopyArea])(client));
  626. }
  627.  
  628. int
  629. SProcCopyPlane(client)
  630.     register ClientPtr client;
  631. {
  632.     register char n;
  633.     REQUEST(xCopyPlaneReq);
  634.     swaps(&stuff->length, n);
  635.     swapl(&stuff->srcDrawable, n);
  636.     swapl(&stuff->dstDrawable, n);
  637.     swapl(&stuff->gc, n);
  638.     swaps(&stuff->srcX, n);
  639.     swaps(&stuff->srcY, n);
  640.     swaps(&stuff->dstX, n);
  641.     swaps(&stuff->dstY, n);
  642.     swaps(&stuff->width, n);
  643.     swaps(&stuff->height, n);
  644.     swapl(&stuff->bitPlane, n);
  645.     return((* ProcVector[X_CopyPlane])(client));
  646. }
  647.  
  648. /* The following routine is used for all Poly drawing requests
  649.    (except FillPoly, which uses a different request format) */
  650. int
  651. SProcPoly(client)
  652.     register ClientPtr client;
  653. {
  654.     register char n;
  655.  
  656.     REQUEST(xPolyPointReq);
  657.     swaps(&stuff->length, n);
  658.     swapl(&stuff->drawable, n);
  659.     swapl(&stuff->gc, n);
  660.     SwapRestS(stuff);
  661.     return((* ProcVector[stuff->reqType])(client));
  662. }
  663.  
  664. /* cannot use SProcPoly for this one, because xFillPolyReq
  665.    is longer than xPolyPointReq, and we don't want to swap
  666.    the difference as shorts! */
  667. int
  668. SProcFillPoly(client)
  669.     register ClientPtr client;
  670. {
  671.     register char n;
  672.  
  673.     REQUEST(xFillPolyReq);
  674.     swaps(&stuff->length, n);
  675.     swapl(&stuff->drawable, n);
  676.     swapl(&stuff->gc, n);
  677.     SwapRestS(stuff);
  678.     return((* ProcVector[X_FillPoly])(client));
  679. }
  680.  
  681. int
  682. SProcPutImage(client)
  683.     register ClientPtr client;
  684. {
  685.     register char n;
  686.     REQUEST(xPutImageReq);
  687.     swaps(&stuff->length, n);
  688.     swapl(&stuff->drawable, n);
  689.     swapl(&stuff->gc, n);
  690.     swaps(&stuff->width, n);
  691.     swaps(&stuff->height, n);
  692.     swaps(&stuff->dstX, n);
  693.     swaps(&stuff->dstY, n);
  694.     /* Image should already be swapped */
  695.     return((* ProcVector[X_PutImage])(client));
  696.  
  697. }
  698.  
  699. int
  700. SProcGetImage(client)
  701.     register ClientPtr    client;
  702. {
  703.     register char n;
  704.     REQUEST(xGetImageReq);
  705.     swaps(&stuff->length, n);
  706.     swapl(&stuff->drawable, n);
  707.     swaps(&stuff->x, n);
  708.     swaps(&stuff->y, n);
  709.     swaps(&stuff->width, n);
  710.     swaps(&stuff->height, n);
  711.     swapl(&stuff->planeMask, n);
  712.     return((* ProcVector[X_GetImage])(client));
  713. }
  714.  
  715. /* ProcPolyText used for both PolyText8 and PolyText16 */
  716.  
  717. int
  718. SProcPolyText(client)
  719.     register ClientPtr client;
  720. {
  721.     register char n;
  722.     REQUEST(xPolyTextReq);
  723.     swaps(&stuff->length, n);
  724.     swapl(&stuff->drawable, n);
  725.     swapl(&stuff->gc, n);
  726.     swaps(&stuff->x, n);
  727.     swaps(&stuff->y, n);
  728.     return((* ProcVector[stuff->reqType])(client));
  729. }
  730.  
  731. /* ProcImageText used for both ImageText8 and ImageText16 */
  732.  
  733. int
  734. SProcImageText(client)
  735.     register ClientPtr client;
  736. {
  737.     register char n;
  738.     REQUEST(xImageTextReq);
  739.     swaps(&stuff->length, n);
  740.     swapl(&stuff->drawable, n);
  741.     swapl(&stuff->gc, n);
  742.     swaps(&stuff->x, n);
  743.     swaps(&stuff->y, n);
  744.     return((* ProcVector[stuff->reqType])(client));
  745. }
  746.  
  747. int
  748. SProcCreateColormap(client)
  749.     register ClientPtr client;
  750. {
  751.     register char n;
  752.     REQUEST(xCreateColormapReq);
  753.     swaps(&stuff->length, n);
  754.     swapl(&stuff->mid, n);
  755.     swapl(&stuff->window, n);
  756.     swapl(&stuff->visual, n);
  757.     return((* ProcVector[X_CreateColormap])(client));
  758. }
  759.  
  760.  
  761. int
  762. SProcCopyColormapAndFree(client)
  763.     register ClientPtr client;
  764. {
  765.     register char n;
  766.     REQUEST(xCopyColormapAndFreeReq);
  767.     swaps(&stuff->length, n);
  768.     swapl(&stuff->mid, n);
  769.     swapl(&stuff->srcCmap, n);
  770.     return((* ProcVector[X_CopyColormapAndFree])(client));
  771.  
  772. }
  773.  
  774. int
  775. SProcAllocColor                (client)
  776.     register ClientPtr client;
  777. {
  778.     register char n;
  779.     REQUEST(xAllocColorReq);
  780.     swaps(&stuff->length, n);
  781.     swapl(&stuff->cmap, n);
  782.     swaps(&stuff->red, n);
  783.     swaps(&stuff->green, n);
  784.     swaps(&stuff->blue, n);
  785.     return((* ProcVector[X_AllocColor])(client));
  786. }
  787.  
  788. int
  789. SProcAllocNamedColor           (client)
  790.     register ClientPtr client;
  791. {
  792.     register char n;
  793.  
  794.     REQUEST(xAllocNamedColorReq);
  795.     swaps(&stuff->length, n);
  796.     swapl(&stuff->cmap, n);
  797.     swaps(&stuff->nbytes, n);
  798.     return((* ProcVector[X_AllocNamedColor])(client));
  799. }
  800.  
  801. int
  802. SProcAllocColorCells           (client)
  803.     register ClientPtr client;
  804. {
  805.     register char n;
  806.     REQUEST(xAllocColorCellsReq);
  807.     swaps(&stuff->length, n);
  808.     swapl(&stuff->cmap, n);
  809.     swaps(&stuff->colors, n);
  810.     swaps(&stuff->planes, n);
  811.     return((* ProcVector[X_AllocColorCells])(client));
  812. }
  813.  
  814. int
  815. SProcAllocColorPlanes(client)
  816.     register ClientPtr client;
  817. {
  818.     register char n;
  819.     REQUEST(xAllocColorPlanesReq);
  820.     swaps(&stuff->length, n);
  821.     swapl(&stuff->cmap, n);
  822.     swaps(&stuff->colors, n);
  823.     swaps(&stuff->red, n);
  824.     swaps(&stuff->green, n);
  825.     swaps(&stuff->blue, n);
  826.     return((* ProcVector[X_AllocColorPlanes])(client));
  827. }
  828.  
  829. int
  830. SProcFreeColors          (client)
  831.     register ClientPtr client;
  832. {
  833.     register char n;
  834.     REQUEST(xFreeColorsReq);
  835.     swaps(&stuff->length, n);
  836.     REQUEST_AT_LEAST_SIZE(xFreeColorsReq);
  837.     swapl(&stuff->cmap, n);
  838.     swapl(&stuff->planeMask, n);
  839.     SwapRestL(stuff);
  840.     return((* ProcVector[X_FreeColors])(client));
  841.  
  842. }
  843.  
  844. int
  845. SProcStoreColors               (client)
  846.     register ClientPtr client;
  847. {
  848.     register char n;
  849.     unsigned long count;
  850.     xColorItem     *pItem;
  851.  
  852.     REQUEST(xStoreColorsReq);
  853.     swaps(&stuff->length, n);
  854.     swapl(&stuff->cmap, n);
  855.     pItem = (xColorItem *) &stuff[1];
  856.     for(count = LengthRestB(stuff)/sizeof(xColorItem); count != 0; count--)
  857.     SwapColorItem(pItem++);
  858.     return((* ProcVector[X_StoreColors])(client));
  859. }
  860.  
  861. int
  862. SProcStoreNamedColor           (client)
  863.     register ClientPtr client;
  864. {
  865.     register char n;
  866.     REQUEST(xStoreNamedColorReq);
  867.     swaps(&stuff->length, n);
  868.     swapl(&stuff->cmap, n);
  869.     swapl(&stuff->pixel, n);
  870.     swaps(&stuff->nbytes, n);
  871.     return((* ProcVector[X_StoreNamedColor])(client));
  872. }
  873.  
  874. int
  875. SProcQueryColors(client)
  876.     register ClientPtr client;
  877. {
  878.     register char n;
  879.     REQUEST(xQueryColorsReq);
  880.     swaps(&stuff->length, n);
  881.     REQUEST_AT_LEAST_SIZE(xQueryColorsReq);
  882.     swapl(&stuff->cmap, n);
  883.     SwapRestL(stuff);
  884.     return((* ProcVector[X_QueryColors])(client));
  885. } 
  886.  
  887. int
  888. SProcLookupColor(client)
  889.     register ClientPtr client;
  890. {
  891.     register char n;
  892.     REQUEST(xLookupColorReq);
  893.     swaps(&stuff->length, n);
  894.     swapl(&stuff->cmap, n);
  895.     swaps(&stuff->nbytes, n);
  896.     return((* ProcVector[X_LookupColor])(client));
  897. }
  898.  
  899. int
  900. SProcCreateCursor( client)
  901.     register ClientPtr client;
  902. {
  903.     register char n;
  904.     REQUEST(xCreateCursorReq);
  905.     swaps(&stuff->length, n);
  906.     swapl(&stuff->cid, n);
  907.     swapl(&stuff->source, n);
  908.     swapl(&stuff->mask, n);
  909.     swaps(&stuff->foreRed, n);
  910.     swaps(&stuff->foreGreen, n);
  911.     swaps(&stuff->foreBlue, n);
  912.     swaps(&stuff->backRed, n);
  913.     swaps(&stuff->backGreen, n);
  914.     swaps(&stuff->backBlue, n);
  915.     swaps(&stuff->x, n);
  916.     swaps(&stuff->y, n);
  917.     return((* ProcVector[X_CreateCursor])(client));
  918. }
  919.  
  920. int
  921. SProcCreateGlyphCursor( client)
  922.     register ClientPtr client;
  923. {
  924.     register char n;
  925.     REQUEST(xCreateGlyphCursorReq);
  926.     swaps(&stuff->length, n);
  927.     swapl(&stuff->cid, n);
  928.     swapl(&stuff->source, n);
  929.     swapl(&stuff->mask, n);
  930.     swaps(&stuff->sourceChar, n);
  931.     swaps(&stuff->maskChar, n);
  932.     swaps(&stuff->foreRed, n);
  933.     swaps(&stuff->foreGreen, n);
  934.     swaps(&stuff->foreBlue, n);
  935.     swaps(&stuff->backRed, n);
  936.     swaps(&stuff->backGreen, n);
  937.     swaps(&stuff->backBlue, n);
  938.     return((* ProcVector[X_CreateGlyphCursor])(client));
  939. }
  940.  
  941.  
  942. int
  943. SProcRecolorCursor(client)
  944.     register ClientPtr client;
  945. {
  946.     register char n;
  947.     REQUEST(xRecolorCursorReq);
  948.     swaps(&stuff->length, n);
  949.     swapl(&stuff->cursor, n);
  950.     swaps(&stuff->foreRed, n);
  951.     swaps(&stuff->foreGreen, n);
  952.     swaps(&stuff->foreBlue, n);
  953.     swaps(&stuff->backRed, n);
  954.     swaps(&stuff->backGreen, n);
  955.     swaps(&stuff->backBlue, n);
  956.     return((* ProcVector[X_RecolorCursor])(client));
  957. }
  958.  
  959. int
  960. SProcQueryBestSize   (client)
  961.     register ClientPtr client;
  962. {
  963.     register char n;
  964.     REQUEST(xQueryBestSizeReq);
  965.     swaps(&stuff->length, n);
  966.     swapl(&stuff->drawable, n);
  967.     swaps(&stuff->width, n);
  968.     swaps(&stuff->height, n);
  969.     return((* ProcVector[X_QueryBestSize])(client));
  970.  
  971. }
  972.  
  973. int
  974. SProcQueryExtension   (client)
  975.     register ClientPtr client;
  976. {
  977.     register char n;
  978.     REQUEST(xQueryExtensionReq);
  979.     swaps(&stuff->length, n);
  980.     swaps(&stuff->nbytes, n);
  981.     return((* ProcVector[X_QueryExtension])(client));
  982. }
  983.  
  984. int
  985. SProcChangeKeyboardMapping   (client)
  986.     register ClientPtr client;
  987. {
  988.     register char n;
  989.     register long *p;
  990.     register int i, count;
  991.  
  992.     REQUEST(xChangeKeyboardMappingReq);
  993.     swaps(&stuff->length, n);
  994.     p = (long *)&stuff[1];
  995.     count = stuff->keyCodes * stuff->keySymsPerKeyCode;
  996.     for(i = 0; i < count; i++)
  997.     {
  998.         swapl(p, n);
  999.     p++;
  1000.     }
  1001.     return((* ProcVector[X_ChangeKeyboardMapping])(client));
  1002. }
  1003.  
  1004.  
  1005. int
  1006. SProcChangeKeyboardControl   (client)
  1007.     register ClientPtr client;
  1008. {
  1009.     register char n;
  1010.     REQUEST(xChangeKeyboardControlReq);
  1011.     swaps(&stuff->length, n);
  1012.     REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq);
  1013.     swapl(&stuff->mask, n);
  1014.     SwapRestL(stuff);
  1015.     return((* ProcVector[X_ChangeKeyboardControl])(client));
  1016. }
  1017.  
  1018. int
  1019. SProcChangePointerControl   (client)
  1020.     register ClientPtr client;
  1021. {
  1022.     register char n;
  1023.     REQUEST(xChangePointerControlReq);
  1024.     swaps(&stuff->length, n);
  1025.     swaps(&stuff->accelNum, n);
  1026.     swaps(&stuff->accelDenum, n);
  1027.     swaps(&stuff->threshold, n);
  1028.     return((* ProcVector[X_ChangePointerControl])(client));
  1029. }
  1030.  
  1031.  
  1032. int
  1033. SProcSetScreenSaver            (client)
  1034.     register ClientPtr client;
  1035. {
  1036.     register char n;
  1037.     REQUEST(xSetScreenSaverReq);
  1038.     swaps(&stuff->length, n);
  1039.     swaps(&stuff->timeout, n);
  1040.     swaps(&stuff->interval, n);
  1041.     return((* ProcVector[X_SetScreenSaver])(client));
  1042. }
  1043.  
  1044. int
  1045. SProcChangeHosts(client)
  1046.     register ClientPtr client;
  1047. {
  1048.     register char n;
  1049.  
  1050.     REQUEST(xChangeHostsReq);
  1051.     swaps(&stuff->length, n);
  1052.     swaps(&stuff->hostLength, n);
  1053.     return((* ProcVector[X_ChangeHosts])(client));
  1054.  
  1055. }
  1056.  
  1057. int SProcRotateProperties(client)
  1058.     register ClientPtr client;
  1059. {
  1060.     register char n;
  1061.     REQUEST(xRotatePropertiesReq);
  1062.     swaps(&stuff->length, n);
  1063.     swapl(&stuff->window, n);
  1064.     swaps(&stuff->nAtoms, n);
  1065.     REQUEST_FIXED_SIZE(xRotatePropertiesReq, stuff->nAtoms << 2);
  1066.     swaps(&stuff->nPositions, n);
  1067.     SwapRestL(stuff);
  1068.     return ((* ProcVector[X_RotateProperties])(client));
  1069. }
  1070.  
  1071. /*ARGSUSED*/
  1072. int
  1073. SProcNoOperation(client)
  1074.     ClientPtr client;
  1075. {
  1076.     /* noop -- don't do anything */
  1077.     return(Success);
  1078. }
  1079.  
  1080. SwapTimecoord(pCoord)
  1081.     xTimecoord *pCoord;
  1082. {
  1083.     register char n;
  1084.  
  1085.     swapl(&pCoord->time, n);
  1086.     swaps(&pCoord->x, n);
  1087.     swaps(&pCoord->y, n);
  1088. }
  1089.  
  1090.  
  1091. SwapRGB(prgb)
  1092.     xrgb    *prgb;
  1093. {
  1094.     register char n;
  1095.  
  1096.     swaps(&prgb->red, n);
  1097.     swaps(&prgb->green, n);
  1098.     swaps(&prgb->blue, n);
  1099. }
  1100.  
  1101. SwapColorItem(pItem)
  1102.     xColorItem    *pItem;
  1103. {
  1104.     register char n;
  1105.  
  1106.     swapl(&pItem->pixel, n);
  1107.     swaps(&pItem->red, n);
  1108.     swaps(&pItem->green, n);
  1109.     swaps(&pItem->blue, n);
  1110. }
  1111.  
  1112. SwapConnClientPrefix(pCCP)
  1113.     xConnClientPrefix    *pCCP;
  1114. {
  1115.     register char n;
  1116.  
  1117.     swaps(&pCCP->majorVersion, n);
  1118.     swaps(&pCCP->minorVersion, n);
  1119.     swaps(&pCCP->nbytesAuthProto, n);
  1120.     swaps(&pCCP->nbytesAuthString, n);
  1121. }
  1122.  
  1123.